/**
 * 🔥 融云IM管理工具类
 * 
 * 功能：
 * - 融云SDK初始化
 * - 连接管理（连接、断开、重连）
 * - 消息发送和接收
 * - 会话管理
 * 
 * 文档：https://docs.rongcloud.cn/miniprogram-imlib
 */

console.log('🔥 [rongcloud.js] 模块开始加载...');

const storage = require('./storage.js');
console.log('✅ [rongcloud.js] storage 模块加载成功:', typeof storage);

const request = require('./request.js');
console.log('✅ [rongcloud.js] request 模块加载成功:', typeof request);

// 融云配置
const RONGCLOUD_CONFIG = {
  appKey: 'x4vkb1qpx8r4k', // 生产环境 App Key
  appSecret: 'UCbIqxWy9XMo', // 生产环境 App Secret
};

// 融云实例
let RongIMLib = null;
let RongIMClient = null;

// 连接状态
let isConnected = false;
let isConnecting = false;

// 消息监听器集合
const messageListeners = new Set();
const connectionListeners = new Set();

/**
 * 🔥 初始化融云SDK
 * 必须在 app.js 中调用
 */
function init() {
  console.log('🚀 =============== 融云IM初始化开始 ===============');
  
  try {
    // 🔥 方式1：优先尝试使用NPM包（推荐）
    try {
      console.log('📦 尝试加载NPM包...');
      RongIMLib = require('@rongcloud/imlib-next');
      console.log('✅ NPM包加载成功');
    } catch (npmError) {
      console.log('⚠️ NPM包加载失败，尝试使用手动下载的SDK...');
      console.log('💡 NPM方式需要：工具 → 构建npm');
      
      // 🔥 方式2：回退到手动下载的SDK文件
      try {
        RongIMLib = require('../lib/RongIMLib-5.9.x.min.js');
        console.log('✅ 手动SDK加载成功');
      } catch (fileError) {
        console.error('❌ 所有加载方式都失败了！');
        console.error('');
        console.error('解决方案：');
        console.error('方案1（推荐）：');
        console.error('  1. 在微信开发者工具中点击：工具 → 构建npm');
        console.error('  2. 等待构建完成');
        console.error('  3. 重新编译小程序');
        console.error('');
        console.error('方案2（临时）：');
        console.error('  1. 访问：https://www.rongcloud.cn/downloads');
        console.error('  2. 下载小程序SDK（5.9.x版本）');
        console.error('  3. 解压后将 RongIMLib-5.9.x.min.js 放到 /miniprogram/lib/ 目录');
        console.error('  4. 重新编译小程序');
        console.error('');
        return false;
      }
    }
    
    if (!RongIMLib) {
      console.error('❌ 融云SDK加载失败');
      return false;
    }
    
    console.log('📦 融云SDK加载成功');
    console.log('📦 SDK版本:', RongIMLib.version || '未知');
    
    // 初始化SDK（5.28.0版本）
    try {
      RongIMLib.init({
        appkey: RONGCLOUD_CONFIG.appKey
      });
      
      // SDK 5.x 版本中，RongIMLib 本身就是客户端
      RongIMClient = RongIMLib;
      
      console.log('✅ 融云SDK初始化成功');
      console.log('📦 App Key:', RONGCLOUD_CONFIG.appKey);
    } catch (initError) {
      console.error('❌ 融云SDK初始化失败:', initError);
      return false;
    }
    
    // 设置连接状态监听
    setupConnectionListener();
    
    // 设置消息监听
    setupMessageListener();
    
    return true;
  } catch (error) {
    console.error('❌ 融云SDK初始化异常:', error);
    return false;
  }
}

/**
 * 🔥 连接融云IM服务器
 * @param {string} token - 融云Token（从后端获取）
 * @returns {Promise}
 */
function connect(token) {
  return new Promise((resolve, reject) => {
    console.log('🔄 =============== 开始连接融云IM ===============');
    
    if (!RongIMClient) {
      console.error('❌ 融云SDK未初始化，请先调用 init()');
      reject(new Error('融云SDK未初始化'));
      return;
    }
    
    if (isConnected) {
      console.log('✅ 已连接到融云IM');
      resolve();
      return;
    }
    
    if (isConnecting) {
      console.log('⚠️ 正在连接中，请稍候...');
      reject(new Error('正在连接中'));
      return;
    }
    
    if (!token) {
      console.error('❌ Token不能为空');
      reject(new Error('Token不能为空'));
      return;
    }
    
    isConnecting = true;
    
    console.log('🔑 使用Token连接:', token.substring(0, 20) + '...');
    
    // 🔥 融云SDK 5.28.0正确的连接方式（参考官方文档）
    // https://docs.rongcloud.cn/miniprogram-imlib/connection/connect
    RongIMLib.connect(token).then((result) => {
      isConnecting = false;
      
      console.log('📦 连接响应:', result);
      console.log('📦 响应码:', result.code);
      
      // 🔥 SDK 5.x 版本：res.code === 0 表示成功
      if (result.code === 0) {
        // 连接成功
        isConnected = true;
        
        console.log('✅ 融云IM连接成功');
        
        // 🔥 用户ID在 result.data.userId 中
        const userId = result.data?.userId;
        console.log('👤 融云用户ID:', userId);
        
        // 保存连接状态和用户ID
        storage.set('rongcloud_connected', true);
        if (userId) {
          storage.set('rongcloud_user_id', userId);
        }
        
        // 通知所有连接监听器
        notifyConnectionListeners(true);
        
        resolve(result);
      } else {
        // 连接失败
        isConnected = false;
        
        console.error('❌ 融云IM连接失败');
        console.error('错误码:', result.code);
        console.error('错误信息:', result.msg);
        
        // 如果是 Token 无效（31004），清除本地Token
        if (result.code === 31004) {
          console.error('🔑 Token 无效或已过期');
          console.error('💡 可能原因：');
          console.error('   1. Token格式不正确');
          console.error('   2. Token已过期');
          console.error('   3. AppKey与Token不匹配');
          storage.remove('rongcloud_token');
        }
        
        // 通知所有连接监听器
        notifyConnectionListeners(false);
        
        reject(result);
      }
    }).catch((error) => {
      isConnecting = false;
      isConnected = false;
      
      console.error('❌ 融云IM连接异常:', error);
      console.error('📦 错误对象:', error);
      
      // 通知所有连接监听器
      notifyConnectionListeners(false);
      
      reject(error);
    });
  });
}

/**
 * 🔥 断开连接
 * @returns {Promise}
 */
function disconnect() {
  return new Promise((resolve, reject) => {
    console.log('🔄 =============== 断开融云IM连接 ===============');
    
    if (!RongIMClient) {
      console.error('❌ 融云SDK未初始化');
      reject(new Error('融云SDK未初始化'));
      return;
    }
    
    if (!isConnected) {
      console.log('⚠️ 未连接到融云IM');
      resolve();
      return;
    }
    
    RongIMClient.disconnect().then(() => {
      isConnected = false;
      
      console.log('✅ 已断开融云IM连接');
      
      // 清除连接状态
      storage.remove('rongcloud_connected');
      
      // 通知所有连接监听器
      notifyConnectionListeners(false);
      
      resolve();
    }).catch((error) => {
      console.error('❌ 断开连接失败:', error);
      reject(error);
    });
  });
}

/**
 * 🔥 发送单聊文本消息
 * @param {string} targetId - 接收者用户ID
 * @param {string} content - 消息内容
 * @returns {Promise}
 */
function sendTextMessage(targetId, content) {
  return new Promise((resolve, reject) => {
    console.log('📤 =============== 发送文本消息 ===============');
    console.log('👤 接收者ID:', targetId);
    console.log('📝 消息内容:', content);
    
    if (!RongIMLib) {
      console.error('❌ 融云SDK未初始化');
      reject(new Error('融云SDK未初始化'));
      return;
    }
    
    if (!isConnected) {
      console.error('❌ 未连接到融云IM');
      reject(new Error('未连接到融云IM'));
      return;
    }
    
    if (!targetId || !content) {
      console.error('❌ 参数不完整');
      reject(new Error('参数不完整'));
      return;
    }
    
    try {
      // 🔥 SDK 5.x 正确的发送方式
      // 参考文档：https://docs.rongcloud.cn/miniprogram-imlib/message/send
      
      // 步骤1：定义目标会话
      const conversation = {
        conversationType: RongIMLib.ConversationType.PRIVATE,
        targetId: String(targetId)
      };
      
      // 步骤2：实例化待发送消息（使用 new，不是 create）
      const message = new RongIMLib.TextMessage({ content: content });
      
      console.log('📦 目标会话:', conversation);
      console.log('📦 消息对象:', message);
      
      // 步骤3：发送消息（conversation 和 message 是两个独立参数）
      RongIMLib.sendMessage(conversation, message).then((result) => {
        console.log('📦 发送结果:', result);
        
        // 🔥 检查返回结果是否成功
        if (result.code && result.code !== 0) {
          console.error('❌ 消息发送失败');
          console.error('错误码:', result.code);
          console.error('错误信息:', result.msg || '未知错误');
          
          reject(new Error(`发送失败 (${result.code}): ${result.msg || '未知错误'}`));
          return;
        }
        
        // 检查必要字段（在 result.data 中）
        if (!result.data || !result.data.messageId || !result.data.sentTime) {
          console.error('❌ 返回结果缺少必要字段');
          console.error('完整结果:', result);
          
          reject(new Error('返回结果格式错误'));
          return;
        }
        
        console.log('✅ 消息发送成功');
        console.log('📨 消息ID:', result.data.messageId);
        console.log('⏰ 发送时间:', result.data.sentTime);
        
        // 返回 result.data（包含完整的消息对象）
        resolve(result.data);
      }).catch((error) => {
        console.error('❌ 消息发送失败:', error);
        console.error('错误码:', error.code);
        console.error('错误信息:', error.msg || error.message);
        
        reject(error);
      });
    } catch (error) {
      console.error('❌ 发送消息异常:', error);
      reject(error);
    }
  });
}

/**
 * 🔥 获取历史消息
 * @param {string} targetId - 对方用户ID
 * @param {number} count - 获取消息数量（默认20条）
 * @param {number} timestamp - 时间戳（获取此时间之前的消息，默认0表示最新）
 * @returns {Promise}
 */
function getHistoryMessages(targetId, count = 20, timestamp = 0) {
  return new Promise((resolve, reject) => {
    console.log('📜 =============== 获取历史消息 ===============');
    console.log('👤 对方ID:', targetId);
    console.log('📊 数量:', count);
    
    if (!RongIMLib) {
      console.error('❌ 融云SDK未初始化');
      reject(new Error('融云SDK未初始化'));
      return;
    }
    
    if (!isConnected) {
      console.error('❌ 未连接到融云IM');
      reject(new Error('未连接到融云IM'));
      return;
    }
    
    try {
      // 🔥 SDK 5.x 正确的获取历史消息方式
      RongIMLib.getHistoryMessages({
        conversationType: RongIMLib.ConversationType.PRIVATE,
        targetId: String(targetId),
        count: count,
        timestamp: timestamp || Date.now()
      }).then((result) => {
        console.log('📦 融云返回结果:', result);
        
        // 🔥 检查返回结果是否成功
        if (result.code && result.code !== 0) {
          // 有错误码，但不一定是严重错误
          console.warn('⚠️ 融云返回错误码:', result.code, result.msg);
          
          // 如果是 25102（可能表示会话不存在或无历史消息），返回空列表
          if (result.code === 25102) {
            console.log('ℹ️ 会话暂无历史消息（可能是新会话）');
            resolve({
              list: [],
              hasMore: false
            });
            return;
          }
          
          // 其他错误
          reject(new Error(`融云错误 ${result.code}: ${result.msg}`));
          return;
        }
        
        // 成功获取消息
        const messageList = result.list || result.data?.list || [];
        console.log('✅ 历史消息获取成功');
        console.log('📊 消息数量:', messageList.length);
        console.log('🔄 是否还有更多:', result.hasMore);
        
        resolve({
          list: messageList,
          hasMore: result.hasMore || false
        });
      }).catch((error) => {
        console.error('❌ 历史消息获取失败:', error);
        reject(error);
      });
    } catch (error) {
      console.error('❌ 获取历史消息异常:', error);
      reject(error);
    }
  });
}

/**
 * 🔥 设置连接状态监听器
 */
function setupConnectionListener() {
  if (!RongIMClient) return;
  
  RongIMClient.addEventListener(RongIMLib.Events.CONNECTION_STATUS, (event) => {
    console.log('🔔 连接状态变化:', event.status);
    
    switch (event.status) {
      case RongIMLib.ConnectionStatus.CONNECTED:
        console.log('✅ 已连接');
        isConnected = true;
        notifyConnectionListeners(true);
        break;
      case RongIMLib.ConnectionStatus.CONNECTING:
        console.log('🔄 连接中...');
        isConnecting = true;
        break;
      case RongIMLib.ConnectionStatus.DISCONNECTED:
        console.log('❌ 已断开');
        isConnected = false;
        isConnecting = false;
        notifyConnectionListeners(false);
        break;
      case RongIMLib.ConnectionStatus.NETWORK_UNAVAILABLE:
        console.log('⚠️ 网络不可用');
        break;
      case RongIMLib.ConnectionStatus.KICKED_OFFLINE_BY_OTHER_CLIENT:
        console.log('⚠️ 被其他端踢下线');
        isConnected = false;
        wx.showModal({
          title: '提示',
          content: '您的账号在其他设备登录，当前设备已下线',
          showCancel: false
        });
        break;
    }
  });
}

/**
 * 🔥 设置消息监听器
 */
function setupMessageListener() {
  if (!RongIMClient) return;
  
  RongIMClient.addEventListener(RongIMLib.Events.MESSAGES, (event) => {
    console.log('📨 收到新消息:', event.messages.length, '条');
    
    event.messages.forEach((message) => {
      console.log('📩 消息详情:', {
        messageId: message.messageId,
        messageType: message.messageType,
        conversationType: message.conversationType,
        targetId: message.targetId,
        sentTime: message.sentTime,
        content: message.content
      });
      
      // 通知所有消息监听器
      notifyMessageListeners(message);
    });
  });
}

/**
 * 🔥 添加消息监听器
 * @param {Function} listener - 监听器函数
 */
function addMessageListener(listener) {
  if (typeof listener === 'function') {
    messageListeners.add(listener);
    console.log('✅ 添加消息监听器，当前总数:', messageListeners.size);
  }
}

/**
 * 🔥 移除消息监听器
 * @param {Function} listener - 监听器函数
 */
function removeMessageListener(listener) {
  messageListeners.delete(listener);
  console.log('✅ 移除消息监听器，当前总数:', messageListeners.size);
}

/**
 * 🔥 通知所有消息监听器
 * @param {Object} message - 消息对象
 */
function notifyMessageListeners(message) {
  messageListeners.forEach((listener) => {
    try {
      listener(message);
    } catch (error) {
      console.error('❌ 消息监听器执行失败:', error);
    }
  });
}

/**
 * 🔥 添加连接状态监听器
 * @param {Function} listener - 监听器函数
 */
function addConnectionListener(listener) {
  if (typeof listener === 'function') {
    connectionListeners.add(listener);
    console.log('✅ 添加连接监听器，当前总数:', connectionListeners.size);
  }
}

/**
 * 🔥 移除连接状态监听器
 * @param {Function} listener - 监听器函数
 */
function removeConnectionListener(listener) {
  connectionListeners.delete(listener);
  console.log('✅ 移除连接监听器，当前总数:', connectionListeners.size);
}

/**
 * 🔥 通知所有连接状态监听器
 * @param {boolean} connected - 是否已连接
 */
function notifyConnectionListeners(connected) {
  connectionListeners.forEach((listener) => {
    try {
      listener(connected);
    } catch (error) {
      console.error('❌ 连接监听器执行失败:', error);
    }
  });
}

/**
 * 🔥 从后端获取融云Token
 * @param {number} userId - 用户ID
 * @returns {Promise<string>} 融云Token
 */
function getRongCloudToken(userId) {
  return new Promise((resolve, reject) => {
    console.log('🔑 =============== 获取融云Token ===============');
    console.log('👤 用户ID:', userId);
    
    // 🔥 调用后端接口获取Token
    wx.request({
      url: `${request.BASE_URL}/user/rongcloud_token/`,
      method: 'POST',
      header: {
        'Content-Type': 'application/json'
      },
      data: {
        user_id: userId
      },
      success(res) {
        console.log('📨 获取Token响应:', res);
        
        if (res.statusCode === 200 && res.data.status === 'success') {
          const token = res.data.token;
          console.log('✅ Token获取成功:', token.substring(0, 20) + '...');
          
          // 保存Token到本地
          storage.set('rongcloud_token', token);
          
          resolve(token);
        } else {
          console.error('❌ Token获取失败:', res.data.message);
          reject(new Error(res.data.message || 'Token获取失败'));
        }
      },
      fail(err) {
        console.error('❌ Token获取请求失败:', err);
        reject(err);
      }
    });
  });
}

/**
 * 🔥 获取连接状态
 * @returns {boolean}
 */
function getConnectionStatus() {
  return isConnected;
}

/**
 * 🔥 清空会话消息（本地）
 * @param {string} targetId - 对方用户ID
 * @returns {Promise}
 */
function clearMessages(targetId) {
  return new Promise((resolve, reject) => {
    console.log('🗑️ =============== 清空会话消息 ===============');
    console.log('👤 对方ID:', targetId);
    
    if (!RongIMLib) {
      console.error('❌ 融云SDK未初始化');
      reject(new Error('融云SDK未初始化'));
      return;
    }
    
    try {
      // 🔥 SDK 5.x 正确的清空消息方式
      RongIMLib.clearMessages({
        conversationType: RongIMLib.ConversationType.PRIVATE,
        targetId: String(targetId)
      }).then(() => {
        console.log('✅ 消息清空成功');
        resolve();
      }).catch((error) => {
        console.error('❌ 消息清空失败:', error);
        reject(error);
      });
    } catch (error) {
      console.error('❌ 清空消息异常:', error);
      reject(error);
    }
  });
}

console.log('🔥 [rongcloud.js] 准备导出模块...');

module.exports = {
  init,
  connect,
  disconnect,
  sendTextMessage,
  getHistoryMessages,
  getRongCloudToken,
  getConnectionStatus,
  clearMessages,
  addMessageListener,
  removeMessageListener,
  addConnectionListener,
  removeConnectionListener,
  RONGCLOUD_CONFIG
};

console.log('✅ [rongcloud.js] 模块导出成功，导出的方法:', Object.keys(module.exports));

